Termination w.r.t. Q proof of /tmp/tmpGJCPZQ/Ex6_15_AEL02

Termination w.r.t. Q of the following Term Rewriting System could be disproven:

Q restricted rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
QUOTE1(n__cons(X, Z)) → ACTIVATE(X)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
UNQUOTE(01) → 0¹
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
FIRST(0, Z) → NIL
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))
QUOTE1(n__first(X, Z)) → FIRST1(activate(X), activate(Z))
FROM(X) → S(X)
QUOTE1(n__cons(X, Z)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → ACTIVATE(X)
UNQUOTE(s1(X)) → UNQUOTE(X)
SEL1(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__0) → 0¹
FIRST(s(X), cons(Y, Z)) → CONS(Y, n__first(X, activate(Z)))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
ACTIVATE(n__cons(X1, X2)) → CONS(X1, X2)
ACTIVATE(n__from(X)) → FROM(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(n__first(X, Z)) → ACTIVATE(X)
QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))
QUOTE(n__s(X)) → QUOTE(activate(X))
FROM(X) → CONS(X, n__from(s(X)))
ACTIVATE(n__nil) → NIL
ACTIVATE(n__s(X)) → S(X)
QUOTE1(n__cons(X, Z)) → ACTIVATE(Z)
UNQUOTE(s1(X)) → S(unquote(X))
FIRST1(s(X), cons(Y, Z)) → ACTIVATE(Z)
QUOTE(n__s(X)) → ACTIVATE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
UNQUOTE1(nil1) → NIL
QUOTE(n__sel(X, Z)) → ACTIVATE(Z)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
QUOTE1(n__first(X, Z)) → ACTIVATE(Z)
FCONS(X, Z) → CONS(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
QUOTE1(n__cons(X, Z)) → ACTIVATE(X)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
UNQUOTE(01) → 0¹
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
FIRST(0, Z) → NIL
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))
QUOTE1(n__first(X, Z)) → FIRST1(activate(X), activate(Z))
FROM(X) → S(X)
QUOTE1(n__cons(X, Z)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → ACTIVATE(X)
UNQUOTE(s1(X)) → UNQUOTE(X)
SEL1(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__0) → 0¹
FIRST(s(X), cons(Y, Z)) → CONS(Y, n__first(X, activate(Z)))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
ACTIVATE(n__cons(X1, X2)) → CONS(X1, X2)
ACTIVATE(n__from(X)) → FROM(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(n__first(X, Z)) → ACTIVATE(X)
QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))
QUOTE(n__s(X)) → QUOTE(activate(X))
FROM(X) → CONS(X, n__from(s(X)))
ACTIVATE(n__nil) → NIL
ACTIVATE(n__s(X)) → S(X)
QUOTE1(n__cons(X, Z)) → ACTIVATE(Z)
UNQUOTE(s1(X)) → S(unquote(X))
FIRST1(s(X), cons(Y, Z)) → ACTIVATE(Z)
QUOTE(n__s(X)) → ACTIVATE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
UNQUOTE1(nil1) → NIL
QUOTE(n__sel(X, Z)) → ACTIVATE(Z)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
QUOTE1(n__first(X, Z)) → ACTIVATE(Z)
FCONS(X, Z) → CONS(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 6 SCCs with 27 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

UNQUOTE(s1(X)) → UNQUOTE(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

From the DPs we obtained the following set of size-change graphs:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)

The remaining pairs can at least be oriented weakly.

ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(ACTIVATE(x₁)) = x₁
POL(FIRST(x₁, x₂)) = 1 + x₂
POL(SEL(x₁, x₂)) = x₂
POL(activate(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁ + x₂
POL(first(x₁, x₂)) = 1 + x₂
POL(from(x₁)) = x₁
POL(n__0) = 0
POL(n__cons(x₁, x₂)) = x₁ + x₂
POL(n__first(x₁, x₂)) = 1 + x₂
POL(n__from(x₁)) = x₁
POL(n__nil) = 1
POL(n__s(x₁)) = 0
POL(n__sel(x₁, x₂)) = 1 + x₂
POL(nil) = 1
POL(s(x₁)) = 0
POL(sel(x₁, x₂)) = 1 + x₂

The following usable rules [17] were oriented:

from(X) → n__from(X)
0 → n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
nil → n__nil
cons(X1, X2) → n__cons(X1, X2)
from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
activate(X) → X
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
first(0, Z) → nil
activate(n__nil) → nil
sel(0, cons(X, Z)) → X

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

                  ↳ QDP

                    ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__s(X)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(X)) → QUOTE(activate(X)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__nil)) → QUOTE(nil) at position [0] we obtained the following new rules:

QUOTE(n__s(n__nil)) → QUOTE(n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__nil)) → QUOTE(n__nil)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__cons(x0, x1))) → QUOTE(n__cons(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(n__cons(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__0)) → QUOTE(0) at position [0] we obtained the following new rules:

QUOTE(n__s(n__0)) → QUOTE(n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(n__0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__s(x0))) → QUOTE(s(x0)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__from(x0))) → QUOTE(from(x0)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__s(n__from(x0))) → QUOTE(n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__from(x0))) → QUOTE(n__from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, n__from(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__from(x0), y1)) → SEL1(n__from(x0), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(n__from(x0), activate(y1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__cons(x0, x1), y2)) → SEL1(n__cons(x0, x1), activate(y2))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__cons(x0, x1), y2)) → SEL1(n__cons(x0, x1), activate(y2))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__nil, y0)) → SEL1(n__nil, activate(y0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__nil, y0)) → SEL1(n__nil, activate(y0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, n__s(x0))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, n__0)
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, n__nil)
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), n__s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), n__nil)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), n__from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), n__0)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), n__from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), n__from(x0))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), n__nil)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), n__0)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, n__s(x0))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__nil)) → SEL1(0, n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, n__nil)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, n__from(x0))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__0)) → SEL1(0, n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, n__0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), n__s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), n__nil)
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), n__from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), n__0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, n__from(x0))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__0)) → SEL1(y0, n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, n__0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                ↳ Narrowing

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__nil)) → SEL1(y0, n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, n__nil)
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
QUOTE(x1) = QUOTE(x1)
n__sel(x1, x2) = n__sel(x1, x2)
n__from(x1) = n__from(x1)
SEL1(x1, x2) = SEL1(x1, x2)
sel(x1, x2) = sel(x1, x2)
cons(x1, x2) = cons(x1, x2)
s(x1) = s(x1)
n__0 = n__0
n__cons(x1, x2) = n__cons(x1, x2)
0 = 0
n__first(x1, x2) = n__first(x1, x2)
first(x1, x2) = first(x1, x2)
n__s(x1) = n__s(x1)
activate(x1) = activate(x1)
from(x1) = from(x1)
nil = nil
n__nil = n__nil

Recursive path order with status [2].
Quasi-Precedence:

[n_{_sel₂}, sel₂, n_{_first₂}, first₂] > [activate₁, from₁] > [SEL1₂, n_₀, 0] > QUOTE₁ > [s₁, n_{_s₁}] > [n_{_from₁}, cons₂, n_{_cons₂}]
[n_{_sel₂}, sel₂, n_{_first₂}, first₂] > [nil, n_{_nil}]

Status:

sel₂: [1,2]
n_{_first₂}: [1,2]
SEL1₂: [1,2]
from₁: [1]
n_{_sel₂}: [1,2]
n_{_cons₂}: multiset
activate₁: [1]
n_{_s₁}: multiset
n_{_nil}: multiset
0: multiset
first₂: [1,2]
cons₂: multiset
n_{_from₁}: multiset
n_₀: multiset
s₁: multiset
nil: multiset
QUOTE₁: [1]

The following usable rules [17] were oriented:

from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
first(0, Z) → nil
sel(0, cons(X, Z)) → X
from(X) → n__from(X)
0 → n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
nil → n__nil
cons(X1, X2) → n__cons(X1, X2)
activate(X) → X
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
activate(n__nil) → nil

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ Narrowing

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Narrowing

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ DependencyGraphProof

                                                                          ↳ QDP

                                                                            ↳ Narrowing

                                                                              ↳ QDP

                                                                                ↳ Narrowing

                                                                                  ↳ QDP

                                                                                    ↳ DependencyGraphProof

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ Narrowing

                                                                                                  ↳ QDP

                                                                                                    ↳ Narrowing

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Narrowing

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Narrowing

                                                                                                                          ↳ QDP

                                                                                                                            ↳ DependencyGraphProof

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Narrowing

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Narrowing

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Narrowing

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Narrowing

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                        ↳ Narrowing

                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPSizeChangeProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

From the DPs we obtained the following set of size-change graphs:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__0)) → QUOTE1(0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__0)) → QUOTE1(0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__0)) → QUOTE1(0) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__0)) → QUOTE1(n__0)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__0)) → QUOTE1(n__0)
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__nil)) → QUOTE1(n__nil)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(n__nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(n__s(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(n__s(x0))
QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(n__from(x0))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(n__from(x0))
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))

The remaining pairs can at least be oriented weakly.

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(QUOTE1(x₁)) = x₁
POL(activate(x₁)) = 1 + x₁
POL(cons(x₁, x₂)) = 1 + x₁ + x₂
POL(first(x₁, x₂)) = 1 + x₂
POL(from(x₁)) = 1 + x₁
POL(n__0) = 0
POL(n__cons(x₁, x₂)) = 1 + x₁ + x₂
POL(n__first(x₁, x₂)) = x₂
POL(n__from(x₁)) = x₁
POL(n__nil) = 0
POL(n__s(x₁)) = 0
POL(n__sel(x₁, x₂)) = 1 + x₂
POL(nil) = 1
POL(s(x₁)) = 0
POL(sel(x₁, x₂)) = 1 + x₂

The following usable rules [17] were oriented:

from(X) → n__from(X)
0 → n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
nil → n__nil
cons(X1, X2) → n__cons(X1, X2)
from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
activate(X) → X
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
first(0, Z) → nil
sel(0, cons(X, Z)) → X
activate(n__nil) → nil

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ Narrowing

              ↳ QDP

                ↳ Narrowing

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ Narrowing

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ Narrowing

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ NonTerminationProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0 → n__0
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

s = QUOTE1(cons(X1, n__from(x0))) evaluates to t =QUOTE1(cons(x0, n__from(s(x0))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:

Semiunifier: [ ]
Matcher: [x0 / s(x0), X1 / x0]

Rewriting sequence

QUOTE1(cons(X1, n__from(x0))) → QUOTE1(n__cons(X1, n__from(x0)))
with rule cons(X1', X2) → n__cons(X1', X2) at position [0] and matcher [X2 / n__from(x0), X1' / X1]

QUOTE1(n__cons(X1, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
with rule QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence

All these steps are and every following step will be a correct step w.r.t to Q.